#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <pthread.h>

///////////////////////////////////////线程局部存储/////////////////////////////////////////
__thread int g_num = 100;

std::string Addr(int &c)
{
    char addr[64];
    snprintf(addr, 64, "%p", &c);
    return addr;
}
void *Func1(void *args)
{
    while (true)
    {
        g_num--;
        std::cout << "thread-1[修改num], num = " << g_num << ", &num: " << Addr(g_num) << std::endl;
        sleep(1);
    }
}

void *Func2(void *args)
{
    while (true)
    {
        std::cout << "thread-2[打印num], num = " << g_num << ", &num: " << Addr(g_num) << std::endl;
        sleep(1);
    }
}
int main()
{
    pthread_t tid1, tid2;
    pthread_create(&tid1, nullptr, Func1, nullptr);
    pthread_create(&tid2, nullptr, Func2, nullptr);

    pthread_join(tid1, nullptr);
    pthread_join(tid2, nullptr);
    return 0;
}

/////////////////////////////////////////线程分离/////////////////////////////////////////
// void* threadfunc(void *arg)
// {
//     pthread_detach(pthread_self()); //线程分离自己
//     std::cout << "线程被分离" << std::endl;

//     std::string name = static_cast<const char*>(arg);
//     int cnt = 3;
//     while(cnt--)
//     {
//         std::cout << name << "运行中..." << std::endl;
//         sleep(1);
//     }
//     return nullptr;
// }
// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, threadfunc, (void*)"新线程1");

//     int cnt = 3;
//     while(cnt--)
//     {
//         sleep(1);
//         std::cout << "main线程运行中..." << std::endl;
//     }

//     int ret = pthread_join(tid, nullptr); //分离的线程会join失败
//     if(ret != 0)
//     {
//         std::cout << "pthread_join error: " << strerror(ret) << std::endl;
//     }
//     return 0;
// }

// void* threadfunc(void *arg)
// {
//     std::string name = static_cast<const char*>(arg);
//     int cnt = 3;
//     while(cnt--)
//     {
//         std::cout << name << "运行中..." << std::endl;
//         sleep(1);
//     }
//     return nullptr;
// }
// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, threadfunc, (void*)"新线程1");

//     pthread_detach(tid); //主线程分离新线程
//     std::cout << "线程被分离" << std::endl;

//     int cnt = 3;
//     while(cnt--)
//     {
//         sleep(1);
//         std::cout << "main线程运行中..." << std::endl;
//     }

//     int ret = pthread_join(tid, nullptr); //分离的线程会join失败
//     if(ret != 0)
//     {
//         std::cout << "pthread_join error: " << strerror(ret) << std::endl;
//     }

//     return 0;
// }

//////////////////////////////////////////线程终止////////////////////////////////////////////

// void* threadfunc(void *arg)
// {
//     std::string name = static_cast<const char*>(arg);
//     while(true)
//     {
//         sleep(1);
//         std::cout << name << "运行中..." << std::endl;
//     }
//     return nullptr;
// }
// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, threadfunc, (void*)"新线程1");

//     sleep(3);
//     pthread_cancel(tid);//新线程运行3秒之后被主线程取消

//     void* ret;
//     pthread_join(tid, &ret);

//     std::cout << "新线程运行结果为:" << (long long)ret << std::endl;
//     return 0;
// }

//////////////////////////////////////////////线程等待///////////////////////////////////////////
// class Add
//  {
//  public:
//      Add(int a, int b)
//          :_a(a), _b(b)
//      {}
//      int Execute()
//      {
//          return _a + _b;
//      }

// private:
//     int _a;
//     int _b;
// };

// class Result
// {
// public:
//     Result(int ret) : _ret(ret)
//     {}
//     int GetRet()
//     {
//         return _ret;
//     }
// private:
//     int _ret;
// };

// void* threadfunc(void *arg)
// {
//     Add *t = static_cast<Add*>(arg);
//     sleep(1);
//     Result *r = new Result(t->Execute());
//     sleep(1);
//     return r;
// }
// int main()
// {
//     pthread_t tid;
//     Add *pa = new Add(11, 22);
//     pthread_create(&tid, nullptr, threadfunc, (void*)pa);

//     Result* ret;
//     pthread_join(tid, (void**)&ret);
//     int n = ret->GetRet();

//     std::cout << "新线程运行结果为:" << n << std:: endl;
//     delete pa;
// }

// void* threadfunc(void *arg)
// {
//     int n = 3;
//     while(n--)
//     {
//         sleep(1);
//         std::cout << (char*)arg << "运行中..." << std::endl;
//     }
//     return (void*)111;
// }
// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, threadfunc, (void*)"新线程1");

//     void* ret;
//     pthread_join(tid, &ret);

//     std::cout << "新线程退出码:" << (long long int)ret << std:: endl;
// }

///////////////////////////////////////线程创建///////////////////////////////////////

// int g_val = 100;

// void* threadfunc(void* arg)
// {
//     while(true)
//     {
//         sleep(1);
//         g_val--; //修改g_val
//     }
//     return nullptr;
// }
// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, threadfunc, (void*)"新线程1");
//     while(true)
//     {
//         //sleep(1);
//         std::cout << "main线程打印g_val:" << g_val << std::endl;
//         sleep(1);
//     }
//     return 0;
// }

// void ShowId(pthread_t &p)
// {
//     //printf("tid:%ld\n", p);
//     printf("tid:0x%lx\n", p);
// }

// void* threadfunc(void* arg)
// {
//     std::string name = static_cast<const char*>(arg);
//     pthread_t tid = pthread_self(); //谁调用就获取谁的
//     printf("新线程调用self获得的");
//     ShowId(tid);

//     while(cnt)
//     {
//         sleep(1);
//         std::cout << name << "运行中..., pid:" << getpid() <<std::endl;
//     }
//     return nullptr;
// }

// int main()
// {
//     pthread_t tid, self_tid;

//     pthread_create(&tid, nullptr, threadfunc, (void*)"线程1"); //新线程入口函数
//     ShowId(tid); //主线程获取新线程的ID

//     self_tid = pthread_self(); //main线程自己的线程ID
//     printf("main线程");
//     ShowId(self_tid);

//     pthread_join(tid, nullptr);//主线程等待
//     return 0;
// }

// void* threadfunc(void* arg) //函数名随便起
// {
//     std::string name = (const char*)arg;
//     while(true)
//     {
//         sleep(1);
//         std::cout << name << "运行中..., pid:" << getpid() <<std::endl;
//         int a = 1;
//         a /= 0; //设置错误让这个线程崩掉
//     }
//     return nullptr;
// }
// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid, nullptr, threadfunc, (void*)"线程1"); //新线程入口函数

//     //主线程继续往后执行
//     while(true)
//     {
//         std::cout << "main线程运行中..., pid:" << getpid() << std::endl;
//         sleep(1);
//     }
//     return 0;
// }
